// 导入标准库头文件
#include <bits/stdc++.h>

// 定义长整型别名
using i64 = long long;

// 使用标准库命名空间
using namespace std;

// T数组存储不同尺寸的预定义图案
const vector<string> T[8]{
        {},
        {},
        {
                ".D",
                "RC"
        },
        {},
        {
                ".DRC",
                "RCDU",
                "DRCD",
                "CLRC"
        },
        {
                ".CLRC",
                "DUCLU",
                "CLURC",
                "DRCDU",
                "CLUCL"
        },
        {},
        {
                ".CLRCRC",
                "DUCLUDU",
                "CLURCCL",
                "DRCDURC",
                "CLUCLDU",
                "DRCDRCD",
                "CLUCLRC"
        },
};

/*
 * 根据给定的行数n和列数m，生成一个满足特定条件的图案。
 * 如果无法生成满足条件的图案，返回空vector。
 * 参数:
 *   n - 图案的行数
 *   m - 图案的列数
 * 返回值:
 *   一个包含n行m列字符的vector，表示生成的图案。
 */
vector<string> get(int n, int m) {
    // 如果n和m的乘积能被3整除，或者n和m对3取余的值不相等，则无法生成图案
    if (n * m % 3 == 0 || n % 3 != m % 3) {
        return {};
    }
    // 初始化答案数组，用点填充
    vector<string> ans(n, string(m, '.'));
    // 第一次循环处理行
    for (int t = 0; t < 2; t++) {
        // 当m大于4且n为偶数时，添加CLRDU图案
        while (n % 2 == 0 && m > 4) {
            for (int i = 0; i < n; i += 2) {
                ans[i][m - 3] = 'C';
                ans[i][m - 2] = 'L';
                ans[i][m - 1] = 'D';
                ans[i + 1][m - 3] = 'U';
                ans[i + 1][m - 2] = 'R';
                ans[i + 1][m - 1] = 'C';
            }
            m -= 3;
        }
        // 第二次循环处理列
        while (m % 2 == 0 && n > 4) {
            for (int i = 0; i < m; i += 2) {
                ans[n - 3][i] = 'C';
                ans[n - 2][i] = 'U';
                ans[n - 1][i] = 'R';
                ans[n - 3][i + 1] = 'L';
                ans[n - 2][i + 1] = 'D';
                ans[n - 1][i + 1] = 'C';
            }
            n -= 3;
        }
    }
    // 处理剩余的m大于7的情况
    while (m > 7) {
        for (int i = 0; i < n - 3; i += 2) {
            for (auto j: {0, 3}) {
                ans[i][m - j - 3] = 'C';
                ans[i][m - j - 2] = 'L';
                ans[i][m - j - 1] = 'D';
                ans[i + 1][m - j - 3] = 'U';
                ans[i + 1][m - j - 2] = 'R';
                ans[i + 1][m - j - 1] = 'C';
            }
        }
        for (int i = m - 6; i < m; i += 2) {
            ans[n - 3][i] = 'C';
            ans[n - 2][i] = 'U';
            ans[n - 1][i] = 'R';
            ans[n - 3][i + 1] = 'L';
            ans[n - 2][i + 1] = 'D';
            ans[n - 1][i + 1] = 'C';
        }
        m -= 6;
    }
    // 处理剩余的n大于7的情况
    while (n > 7) {
        for (int i = 0; i < m - 3; i += 2) {
            for (auto j: {0, 3}) {
                ans[n - j - 3][i] = 'C';
                ans[n - j - 2][i] = 'U';
                ans[n - j - 1][i] = 'R';
                ans[n - j - 3][i + 1] = 'L';
                ans[n - j - 2][i + 1] = 'D';
                ans[n - j - 1][i + 1] = 'C';
            }
        }
        for (int i = n - 6; i < n; i += 2) {
            ans[i][m - 3] = 'C';
            ans[i][m - 2] = 'L';
            ans[i][m - 1] = 'D';
            ans[i + 1][m - 3] = 'U';
            ans[i + 1][m - 2] = 'R';
            ans[i + 1][m - 1] = 'C';
        }
        n -= 6;
    }
    // 根据n的值，从T数组中复制对应图案到答案数组
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            ans[i][j] = T[n][i][j];
        }
    }
    // 反转每一行，并将L和R字符互换
    for (int i = 0; i < ans.size(); i++) {
        reverse(ans[i].begin(), ans[i].end());
        for (auto &x: ans[i]) {
            if (x == 'L') {
                x = 'R';
            } else if (x == 'R') {
                x = 'L';
            }
        }
    }
    return ans;
}

/*
 * 检查给定的图案是否满足覆盖条件。
 * 参数:
 *   n - 图案的行数
 *   m - 图案的列数
 *   s - 表示图案的二维字符数组
 * 返回值:
 *   如果图案满足覆盖条件，返回true；否则返回false。
 */
bool check(int n, int m, vector<string> s) {
    // 初始化标记变量ok为1，表示覆盖条件满足
    int ok = 1;
    // 初始化计数数组，用于记录每个中心点被覆盖的情况
    vector<vector<array<int, 2>>> cnt(n, vector<array<int, 2>>(m));
    // 遍历图案中的每个位置
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            // 检查边缘位置是否被正确覆盖
            if (s[i][j] == '.' != (i == 0 && j == m - 1)) {
                ok = 0;
            }
            // 如果当前位置不是空点，则检查其覆盖中心点的情况
            if (s[i][j] != '.' && s[i][j] != 'C') {
                // 初始化当前位置的坐标和方向
                int x = i, y = j;
                int z = 0;
                // 根据当前位置的字符确定方向和目标坐标
                if (s[i][j] == 'L') {
                    y--;
                } else if (s[i][j] == 'R') {
                    y++;
                } else if (s[i][j] == 'U') {
                    z = 1;
                    x--;
                } else {
                    z = 1;
                    x++;
                }
                // 如果目标坐标有效且是中心点，则增加对应方向的计数
                if (0 <= x && x < n && 0 <= y && y < m && s[x][y] == 'C') {
                    cnt[x][y][z]++;
                } else {
                    // 如果目标坐标无效或不是中心点，则覆盖不满足
                    ok = 0;
                }
            }
            // 检查每个中心点是否被上下左右四个方向正确覆盖
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (s[i][j] == 'C' && (cnt[i][j][0] != 1 || cnt[i][j][1] != 1)) {
                        ok = 0;
                    }
                }
            }
        }
    }
    // 返回覆盖条件是否满足
    return ok;
}

/*
 * 主函数，用于解决给定尺寸的图案问题。
 */
void solve() {
    // 输入图案的行数和列数
    int n, m;
    cin >> n >> m;
    // 调用get函数尝试生成满足条件的图案
    auto ans = get(n, m);
    // 如果生成的图案为空，则输出"No"；否则输出"Yes"和图案
    if (ans.empty()) {
        cout << "No\n";
    } else {
        cout << "Yes\n";
        for (int i = 0; i < n; i++) {
            cout << ans[i] << "\n";
        }
        // 断言检查生成的图案是否满足覆盖条件
//        assert(check(n,m,ans));
    }
}

// 程序入口
int main() {
    // 关闭同步标准输入输出，提高输入输出效率
    ios::sync_with_stdio(false);
    // 解绑cin和cout，使用C++风格的输入输出
    cin.tie(nullptr);

    // 测试代码

//    for(int i = 2; i <= 100 ; i ++){
//        for(int j = 2 ; j <= 100 ; j++){
//            int n = i, m = j;
//            auto ans = get(n, m);
//            if (ans.empty()) {
//                cout << "No\n";
//            } else {
//                cout << "Yes\n";
//                for (int i = 0; i < n; i++) {
//                    cout << ans[i] << "\n";
//                }
//                assert(check(n,m,ans));
//            }
//        }
//    }
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}